package com.chatai.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * AI服务类 - 处理与阿里云百炼AI模型的交互
 */
@Service
public class AIService {
    // 常量定义
    private static final Logger logger = LoggerFactory.getLogger(AIService.class);
    private static final String DEFAULT_MODEL_ID = "qwen-turbo";
    private static final int MIN_RESPONSE_LENGTH = 5;
    private static final int MAX_PROMPT_LOG_LENGTH = 50;
    
    // 配置项
    @Value("${apiKey:sk-d0378514964148fab84e16e9098f31ec}")
    private String apiKey;
    
    @Value("${alibabacloud.api.url:https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation}")
    private String apiUrl;
    
    @Value("${ai.account:1465561500142613}")
    private String aiAccount;

    // 支持的阿里云百炼模型列表 (使用不可变集合)
    // 注意：当前未直接使用，但保留以备将来扩展使用
    private final Map<String, String> modelMap;
    
    // 模型详细信息 (使用不可变集合)
    private final Map<String, Map<String, String>> modelDetails;
    
    // 模型回复模板 (使用不可变集合)
    private final Map<String, String> fallbackResponses;
    private final Map<String, String> simpleResponses;
    
    /**
     * 构造函数，初始化支持的模型列表和相关数据
     */
    public AIService() {
        // 初始化模型映射，只保留阿里云百炼的模型
        Map<String, String> mutableModelMap = new HashMap<>();
        mutableModelMap.put("qwen-turbo", "qwen-turbo");
        mutableModelMap.put("qwen-plus", "qwen-plus");
        mutableModelMap.put("qwen-max", "qwen-max");
        this.modelMap = Collections.unmodifiableMap(mutableModelMap);
        
        // 初始化模型详细信息，只保留阿里云百炼的模型
        Map<String, Map<String, String>> mutableModelDetails = new HashMap<>();
        addModelDetails(mutableModelDetails, "qwen-turbo", "通义千问 Turbo", "阿里云百炼的高性能对话模型", "对话");
        addModelDetails(mutableModelDetails, "qwen-plus", "通义千问 Plus", "阿里云百炼的高级对话模型", "对话");
        addModelDetails(mutableModelDetails, "qwen-max", "通义千问 Max", "阿里云百炼的旗舰对话模型", "对话");
        this.modelDetails = Collections.unmodifiableMap(mutableModelDetails);
        
        // 初始化简单回复模板
        Map<String, String> mutableSimpleResponses = new HashMap<>();
        mutableSimpleResponses.put("你好", "你好！很高兴认识你！");
        mutableSimpleResponses.put("你是谁", "我是一个AI聊天助手，使用阿里云百炼提供服务。");
        mutableSimpleResponses.put("你能做什么", "我可以回答问题、进行对话，使用阿里云百炼的通义千问模型。");
        mutableSimpleResponses.put("天气", "抱歉，我当前无法获取实时天气信息。");
        mutableSimpleResponses.put("时间", "现在的时间需要您查看系统时钟，我暂时无法直接获取。");
        this.simpleResponses = Collections.unmodifiableMap(mutableSimpleResponses);
        
        // 初始化模型备用回复模板，只保留阿里云百炼的模型
        Map<String, String> mutableFallbackResponses = new HashMap<>();
        mutableFallbackResponses.put("qwen-turbo", "感谢您的提问！我正在使用阿里云百炼的通义千问Turbo模型为您服务。");
        mutableFallbackResponses.put("qwen-plus", "感谢您的提问！我正在使用阿里云百炼的通义千问Plus模型为您服务。");
        mutableFallbackResponses.put("qwen-max", "感谢您的提问！我正在使用阿里云百炼的通义千问Max模型为您服务。");
        this.fallbackResponses = Collections.unmodifiableMap(mutableFallbackResponses);
    }
    
    /**
     * 添加模型详细信息到指定的可变Map中
     */
    private void addModelDetails(Map<String, Map<String, String>> targetMap, String modelId, String name, String description, String type) {
        Map<String, String> details = new HashMap<>();
        details.put("id", modelId);
        details.put("name", name);
        details.put("description", description);
        details.put("type", type);
        targetMap.put(modelId, Collections.unmodifiableMap(details));
    }

    /**
     * 获取可用模型列表
     * @return 模型列表
     */
    public List<Map<String, String>> getAvailableModels() {
        List<Map<String, String>> modelsList = new ArrayList<>();
        
        // 添加所有阿里云百炼模型
        for (Map<String, String> model : modelDetails.values()) {
            // 添加模型的副本以避免外部修改
            modelsList.add(new HashMap<>(model));
        }
        
        return Collections.unmodifiableList(modelsList);
    }
    
    /**
     * 格式化模型名称，使其更易于阅读
     * @param modelId 模型ID
     * @return 格式化后的模型名称
     */
    private String formatModelName(String modelId) {
        if (modelId == null) {
            return "未知模型";
        }
        
        Map<String, String> details = modelDetails.get(modelId);
        if (details != null) {
            return details.get("name");
        }
        
        // 作为备用的硬编码映射，只保留阿里云百炼的模型
        switch (modelId) {
            case "qwen-turbo": return "通义千问 Turbo";
            case "qwen-plus": return "通义千问 Plus";
            case "qwen-max": return "通义千问 Max";
            default: return modelId;
        }
    }

    /**
     * 调用AI API获取回复（使用默认模型）
     * @param prompt 用户提示词
     * @return AI回复内容
     */
    public String getAIResponse(String prompt) {
        return getAIResponse(prompt, DEFAULT_MODEL_ID);
    }
    
    /**
     * 调用AI API获取回复（支持指定模型）
     * @param prompt 用户提示词
     * @param modelId 模型ID
     * @return AI回复内容
     */
    public String getAIResponse(String prompt, String modelId) {
        try {
            // 参数验证
            if (prompt == null || prompt.trim().isEmpty()) {
                throw new IllegalArgumentException("提示词不能为空");
            }
            
            // 直接调用阿里云百炼API（不再需要根据provider选择）
            return callAlibabaCloudAPI(prompt, modelId);
        } catch (IllegalArgumentException e) {
            logger.error("参数错误: {}", e.getMessage());
            return e.getMessage();
        } catch (Exception e) {
            logger.error("调用AI服务时出错: {}", e.getMessage(), e);
            return "调用AI服务时出错: " + e.getMessage();
        }
    }

    // 已移除Hugging Face API支持，仅保留阿里云百炼API支持
    
    // 已移除通用请求构建方法，阿里云百炼API使用专用请求构建逻辑
    
    // 已移除通用响应解析方法，阿里云百炼API使用专用响应解析逻辑
    
    /**
     * 处理API错误
     */
    private String handleApiError(Exception e, String prompt, String modelId) {
        String errorMessage;
        if (e instanceof HttpClientErrorException) {
            HttpClientErrorException httpEx = (HttpClientErrorException) e;
            errorMessage = String.format("API请求被拒绝: %s (状态码: %d)", 
                    httpEx.getMessage(), httpEx.getStatusCode().value());
        } else if (e instanceof HttpServerErrorException) {
            HttpServerErrorException httpEx = (HttpServerErrorException) e;
            errorMessage = String.format("API服务器错误: %s (状态码: %d)", 
                    httpEx.getMessage(), httpEx.getStatusCode().value());
        } else {
            errorMessage = "API调用失败: " + e.getMessage();
        }
        
        logger.warn("使用备用响应，原因为: {}", errorMessage);
        return getEnhancedFallbackResponse(prompt, modelId);
    }
    
    /**
     * 格式化AI响应，去除冗余信息
     */
    private String formatResponse(String rawResponse, String originalPrompt) {
        // 移除原始提示词（如果存在）
        String response = rawResponse;
        if (rawResponse.contains(originalPrompt)) {
            response = rawResponse.substring(rawResponse.indexOf(originalPrompt) + originalPrompt.length()).trim();
        }
        
        // 去除首尾空白
        response = response.trim();
        
        // 如果响应为空或太短，使用模拟回复
        if (response.isEmpty() || response.length() < MIN_RESPONSE_LENGTH) {
            return getEnhancedFallbackResponse(originalPrompt);
        }
        
        return response;
    }
    
    /**
     * 获取增强的备用响应
     */
    private String getEnhancedFallbackResponse(String message) {
        return getEnhancedFallbackResponse(message, DEFAULT_MODEL_ID);
    }
    
    /**
     * 获取增强的备用响应
     */
    private String getEnhancedFallbackResponse(String message, String modelId) {
        // 检查是否有匹配的简单回复
        for (Map.Entry<String, String> entry : simpleResponses.entrySet()) {
            if (message.contains(entry.getKey())) {
                return entry.getValue();
            }
        }
        
        // 获取模型特定的回复
        String modelResponse = fallbackResponses.getOrDefault(modelId, 
                "感谢您的提问！我正在使用免费的AI模型为您服务。");
        
        // 添加模型标识信息
        return new StringBuilder(modelResponse)
                .append("\n\n[模型: ")
                .append(formatModelName(modelId))
                .append("]")
                .toString();
    }
    
    /**
     * 调用阿里云百炼API
     */
    private String callAlibabaCloudAPI(String prompt, String modelId) {
        try {
            logger.info("开始调用阿里云百炼API，模型: {}, 提示词: {}", modelId, truncatePrompt(prompt));
            
            // 设置请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            
            // 模拟环境，直接返回响应而不调用真实API
            logger.info("模拟环境，使用本地响应替代真实API调用");
            return getSimulatedAIResponse(prompt, modelId);
            
            /* 以下是真实API调用代码，暂时注释掉
            // 检查API密钥
            if (apiKey == null || apiKey.isEmpty() || apiKey.equals(TEST_API_KEY)) {
                logger.warn("阿里云百炼API密钥未配置或无效");
                return "阿里云百炼API调用需要有效的API密钥";
            }
            
            headers.set("Authorization", "Bearer " + apiKey);

            // 构建请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", modelMap.getOrDefault(modelId, DEFAULT_MODEL_ID));
            
            // 设置输入内容
            Map<String, Object> input = new HashMap<>();
            input.put("prompt", prompt);
            requestBody.put("input", input);
            
            // 设置参数
            Map<String, Object> parameters = new HashMap<>();
            parameters.put("temperature", 0.7);
            parameters.put("max_tokens", 1000);
            requestBody.put("parameters", parameters);

            // 创建请求实体
            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);

            // 发送请求并获取响应
            @SuppressWarnings("unchecked")
            Map<String, Object> response = restTemplate.postForObject(ALIBABA_CLOUD_URL, entity, Map.class);

            // 解析响应
            if (response != null && response.containsKey("output")) {
                Map<?, ?> output = (Map<?, ?>) response.get("output");
                if (output.containsKey("text")) {
                    String text = (String) output.get("text");
                    return formatResponse(text, prompt);
                }
            }

            return "抱歉，我无法回答这个问题。";
            */
        } catch (Exception e) {
            logger.error("阿里云百炼API调用失败: {}", e.getMessage(), e);
            return handleApiError(e, prompt, modelId);
        }
    }
    
    /**
     * 获取模拟的AI响应（用于测试环境）
     */
    private String getSimulatedAIResponse(String prompt, String modelId) {
        logger.info("生成模拟AI响应");
        
        // 根据提示词生成简单的模拟响应
        String modelName = modelDetails.getOrDefault(modelId, modelDetails.get(DEFAULT_MODEL_ID)).get("name");
        
        if (prompt.contains("你好") || prompt.contains("您好")) {
            return "你好！我是您的AI助手。很高兴为您服务！[模型: " + modelName + "]";
        } else if (prompt.contains("你是谁") || prompt.contains("介绍")) {
            return "我是一个基于人工智能的聊天助手，使用" + modelName + "模型为您提供服务。[模型: " + modelName + "]";
        } else if (prompt.contains("谢谢") || prompt.contains("感谢")) {
            return "不客气！如果您有任何问题，随时可以问我。[模型: " + modelName + "]";
        } else {
            return "这是对您问题的回复。在实际环境中，这里会调用真实的AI模型生成更智能的回答。[模型: " + modelName + "]\n\n您的问题: " + prompt;
        }
    }
    
    /**
     * 截断提示词用于日志记录
     */
    private String truncatePrompt(String prompt) {
        if (prompt.length() <= MAX_PROMPT_LOG_LENGTH) {
            return prompt;
        }
        return prompt.substring(0, MAX_PROMPT_LOG_LENGTH) + "...";
    }
    
    // 已移除OpenAI API支持，仅保留阿里云百炼API支持
}